// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.supplier.task.instance;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SupplierTaskInstance;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SupplierTaskInstance.class)
@Setter
@Getter
public class SupplierTaskInstanceSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SupplierTaskInstance".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("taskId", "st");
    map.put("productId", "p");
    map.put("doUser", "su");
    map.put("forwardUser", "su2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 开发编号
   */
  private Long taskId;

  /**
   * 开发编号 比较(eq)
   */
  private Long taskIdEq;
  /**
   * 开发编号 比较(neq)
   */
  private Long taskIdNeq;
  /**
   * 开发编号 比较(gt)
   */
  private Long taskIdGt;
  /**
   * 开发编号 比较(gte)
   */
  private Long taskIdGte;
  /**
   * 开发编号 比较(lt)
   */
  private Long taskIdLt;
  /**
   * 开发编号 比较(lte)
   */
  private Long taskIdLte;
  /**
   * 开发编号 比较(contains)
   */
  private Long taskIdContains;
  /**
   * 开发编号 比较(notcontains)
   */
  private Long taskIdNotcontains;
  /**
   * 开发编号 比较(startswith)
   */
  private Long taskIdStartswith;
  /**
   * 开发编号 比较(endswith)
   */
  private Long taskIdEndswith;
  /**
   * 开发编号 比较(isnull)
   */
  private Boolean taskIdIsnull;
  /**
   * 开发编号 比较(isnotnull)
   */
  private Boolean taskIdIsnotnull;
  /**
   * 开发编号的任务编号 比较(eq)
   */
  private String taskIdTaskIdEq;
  /**
   * 开发编号的任务编号 比较(neq)
   */
  private String taskIdTaskIdNeq;
  /**
   * 开发编号的任务编号 比较(gt)
   */
  private String taskIdTaskIdGt;
  /**
   * 开发编号的任务编号 比较(gte)
   */
  private String taskIdTaskIdGte;
  /**
   * 开发编号的任务编号 比较(lt)
   */
  private String taskIdTaskIdLt;
  /**
   * 开发编号的任务编号 比较(lte)
   */
  private String taskIdTaskIdLte;
  /**
   * 开发编号的任务编号 比较(contains)
   */
  private String taskIdTaskIdContains;
  /**
   * 开发编号的任务编号 比较(notcontains)
   */
  private String taskIdTaskIdNotcontains;
  /**
   * 开发编号的任务编号 比较(startswith)
   */
  private String taskIdTaskIdStartswith;
  /**
   * 开发编号的任务编号 比较(endswith)
   */
  private String taskIdTaskIdEndswith;
  /**
   * 开发编号的任务编号 比较(isnull)
   */
  private Boolean taskIdTaskIdIsnull;
  /**
   * 开发编号的任务编号 比较(isnotnull)
   */
  private Boolean taskIdTaskIdIsnotnull;

  /**
   * 开发编号(范围搜索)
   */
  private List<Long> taskIdInList;

  /**
   * 任务编号(模糊搜索)
   */
  private String instanceId;

  /**
   * 任务编号 比较(eq)
   */
  private String instanceIdEq;
  /**
   * 任务编号 比较(neq)
   */
  private String instanceIdNeq;
  /**
   * 任务编号 比较(gt)
   */
  private String instanceIdGt;
  /**
   * 任务编号 比较(gte)
   */
  private String instanceIdGte;
  /**
   * 任务编号 比较(lt)
   */
  private String instanceIdLt;
  /**
   * 任务编号 比较(lte)
   */
  private String instanceIdLte;
  /**
   * 任务编号 比较(contains)
   */
  private String instanceIdContains;
  /**
   * 任务编号 比较(notcontains)
   */
  private String instanceIdNotcontains;
  /**
   * 任务编号 比较(startswith)
   */
  private String instanceIdStartswith;
  /**
   * 任务编号 比较(endswith)
   */
  private String instanceIdEndswith;
  /**
   * 任务编号 比较(isnull)
   */
  private Boolean instanceIdIsnull;
  /**
   * 任务编号 比较(isnotnull)
   */
  private Boolean instanceIdIsnotnull;

  /**
   * 任务编号(精确搜索)
   */
  private List<String> instanceIdInList;

  /**
   * 产品
   */
  private Long productId;

  /**
   * 产品 比较(eq)
   */
  private Long productIdEq;
  /**
   * 产品 比较(neq)
   */
  private Long productIdNeq;
  /**
   * 产品 比较(gt)
   */
  private Long productIdGt;
  /**
   * 产品 比较(gte)
   */
  private Long productIdGte;
  /**
   * 产品 比较(lt)
   */
  private Long productIdLt;
  /**
   * 产品 比较(lte)
   */
  private Long productIdLte;
  /**
   * 产品 比较(contains)
   */
  private Long productIdContains;
  /**
   * 产品 比较(notcontains)
   */
  private Long productIdNotcontains;
  /**
   * 产品 比较(startswith)
   */
  private Long productIdStartswith;
  /**
   * 产品 比较(endswith)
   */
  private Long productIdEndswith;
  /**
   * 产品 比较(isnull)
   */
  private Boolean productIdIsnull;
  /**
   * 产品 比较(isnotnull)
   */
  private Boolean productIdIsnotnull;
  /**
   * 产品的品名 比较(eq)
   */
  private String productIdNameEq;
  /**
   * 产品的品名 比较(neq)
   */
  private String productIdNameNeq;
  /**
   * 产品的品名 比较(gt)
   */
  private String productIdNameGt;
  /**
   * 产品的品名 比较(gte)
   */
  private String productIdNameGte;
  /**
   * 产品的品名 比较(lt)
   */
  private String productIdNameLt;
  /**
   * 产品的品名 比较(lte)
   */
  private String productIdNameLte;
  /**
   * 产品的品名 比较(contains)
   */
  private String productIdNameContains;
  /**
   * 产品的品名 比较(notcontains)
   */
  private String productIdNameNotcontains;
  /**
   * 产品的品名 比较(startswith)
   */
  private String productIdNameStartswith;
  /**
   * 产品的品名 比较(endswith)
   */
  private String productIdNameEndswith;
  /**
   * 产品的品名 比较(isnull)
   */
  private Boolean productIdNameIsnull;
  /**
   * 产品的品名 比较(isnotnull)
   */
  private Boolean productIdNameIsnotnull;

  /**
   * 产品(范围搜索)
   */
  private List<Long> productIdInList;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早开发时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date doTimeStart;

  /**
   * 最晚开发时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date doTimeEnd;

  /**
   * 开发时间 比较(eq)
   */
  private Date doTimeEq;
  /**
   * 开发时间 比较(neq)
   */
  private Date doTimeNeq;
  /**
   * 开发时间 比较(gt)
   */
  private Date doTimeGt;
  /**
   * 开发时间 比较(gte)
   */
  private Date doTimeGte;
  /**
   * 开发时间 比较(lt)
   */
  private Date doTimeLt;
  /**
   * 开发时间 比较(lte)
   */
  private Date doTimeLte;
  /**
   * 开发时间 比较(contains)
   */
  private Date doTimeContains;
  /**
   * 开发时间 比较(notcontains)
   */
  private Date doTimeNotcontains;
  /**
   * 开发时间 比较(startswith)
   */
  private Date doTimeStartswith;
  /**
   * 开发时间 比较(endswith)
   */
  private Date doTimeEndswith;
  /**
   * 开发时间 比较(isnull)
   */
  private Boolean doTimeIsnull;
  /**
   * 开发时间 比较(isnotnull)
   */
  private Boolean doTimeIsnotnull;

  /**
   * 最早截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endTimeStart;

  /**
   * 最晚截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endTimeEnd;

  /**
   * 截止时间 比较(eq)
   */
  private Date endTimeEq;
  /**
   * 截止时间 比较(neq)
   */
  private Date endTimeNeq;
  /**
   * 截止时间 比较(gt)
   */
  private Date endTimeGt;
  /**
   * 截止时间 比较(gte)
   */
  private Date endTimeGte;
  /**
   * 截止时间 比较(lt)
   */
  private Date endTimeLt;
  /**
   * 截止时间 比较(lte)
   */
  private Date endTimeLte;
  /**
   * 截止时间 比较(contains)
   */
  private Date endTimeContains;
  /**
   * 截止时间 比较(notcontains)
   */
  private Date endTimeNotcontains;
  /**
   * 截止时间 比较(startswith)
   */
  private Date endTimeStartswith;
  /**
   * 截止时间 比较(endswith)
   */
  private Date endTimeEndswith;
  /**
   * 截止时间 比较(isnull)
   */
  private Boolean endTimeIsnull;
  /**
   * 截止时间 比较(isnotnull)
   */
  private Boolean endTimeIsnotnull;

  /**
   * 执行人员
   */
  private Long doUser;

  /**
   * 执行人员 比较(eq)
   */
  private Long doUserEq;
  /**
   * 执行人员 比较(neq)
   */
  private Long doUserNeq;
  /**
   * 执行人员 比较(gt)
   */
  private Long doUserGt;
  /**
   * 执行人员 比较(gte)
   */
  private Long doUserGte;
  /**
   * 执行人员 比较(lt)
   */
  private Long doUserLt;
  /**
   * 执行人员 比较(lte)
   */
  private Long doUserLte;
  /**
   * 执行人员 比较(contains)
   */
  private Long doUserContains;
  /**
   * 执行人员 比较(notcontains)
   */
  private Long doUserNotcontains;
  /**
   * 执行人员 比较(startswith)
   */
  private Long doUserStartswith;
  /**
   * 执行人员 比较(endswith)
   */
  private Long doUserEndswith;
  /**
   * 执行人员 比较(isnull)
   */
  private Boolean doUserIsnull;
  /**
   * 执行人员 比较(isnotnull)
   */
  private Boolean doUserIsnotnull;
  /**
   * 执行人员的显示用户名 比较(eq)
   */
  private String doUserNameEq;
  /**
   * 执行人员的显示用户名 比较(neq)
   */
  private String doUserNameNeq;
  /**
   * 执行人员的显示用户名 比较(gt)
   */
  private String doUserNameGt;
  /**
   * 执行人员的显示用户名 比较(gte)
   */
  private String doUserNameGte;
  /**
   * 执行人员的显示用户名 比较(lt)
   */
  private String doUserNameLt;
  /**
   * 执行人员的显示用户名 比较(lte)
   */
  private String doUserNameLte;
  /**
   * 执行人员的显示用户名 比较(contains)
   */
  private String doUserNameContains;
  /**
   * 执行人员的显示用户名 比较(notcontains)
   */
  private String doUserNameNotcontains;
  /**
   * 执行人员的显示用户名 比较(startswith)
   */
  private String doUserNameStartswith;
  /**
   * 执行人员的显示用户名 比较(endswith)
   */
  private String doUserNameEndswith;
  /**
   * 执行人员的显示用户名 比较(isnull)
   */
  private Boolean doUserNameIsnull;
  /**
   * 执行人员的显示用户名 比较(isnotnull)
   */
  private Boolean doUserNameIsnotnull;

  /**
   * 执行人员(范围搜索)
   */
  private List<Long> doUserInList;

  /**
   * 企业代码(模糊搜索)
   */
  private String supplierCode;

  /**
   * 企业代码 比较(eq)
   */
  private String supplierCodeEq;
  /**
   * 企业代码 比较(neq)
   */
  private String supplierCodeNeq;
  /**
   * 企业代码 比较(gt)
   */
  private String supplierCodeGt;
  /**
   * 企业代码 比较(gte)
   */
  private String supplierCodeGte;
  /**
   * 企业代码 比较(lt)
   */
  private String supplierCodeLt;
  /**
   * 企业代码 比较(lte)
   */
  private String supplierCodeLte;
  /**
   * 企业代码 比较(contains)
   */
  private String supplierCodeContains;
  /**
   * 企业代码 比较(notcontains)
   */
  private String supplierCodeNotcontains;
  /**
   * 企业代码 比较(startswith)
   */
  private String supplierCodeStartswith;
  /**
   * 企业代码 比较(endswith)
   */
  private String supplierCodeEndswith;
  /**
   * 企业代码 比较(isnull)
   */
  private Boolean supplierCodeIsnull;
  /**
   * 企业代码 比较(isnotnull)
   */
  private Boolean supplierCodeIsnotnull;

  /**
   * 企业代码(精确搜索)
   */
  private List<String> supplierCodeInList;

  /**
   * 企业简称(模糊搜索)
   */
  private String supplierName;

  /**
   * 企业简称 比较(eq)
   */
  private String supplierNameEq;
  /**
   * 企业简称 比较(neq)
   */
  private String supplierNameNeq;
  /**
   * 企业简称 比较(gt)
   */
  private String supplierNameGt;
  /**
   * 企业简称 比较(gte)
   */
  private String supplierNameGte;
  /**
   * 企业简称 比较(lt)
   */
  private String supplierNameLt;
  /**
   * 企业简称 比较(lte)
   */
  private String supplierNameLte;
  /**
   * 企业简称 比较(contains)
   */
  private String supplierNameContains;
  /**
   * 企业简称 比较(notcontains)
   */
  private String supplierNameNotcontains;
  /**
   * 企业简称 比较(startswith)
   */
  private String supplierNameStartswith;
  /**
   * 企业简称 比较(endswith)
   */
  private String supplierNameEndswith;
  /**
   * 企业简称 比较(isnull)
   */
  private Boolean supplierNameIsnull;
  /**
   * 企业简称 比较(isnotnull)
   */
  private Boolean supplierNameIsnotnull;

  /**
   * 企业简称(精确搜索)
   */
  private List<String> supplierNameInList;

  /**
   * 企业名称(模糊搜索)
   */
  private String supplierFullName;

  /**
   * 企业名称 比较(eq)
   */
  private String supplierFullNameEq;
  /**
   * 企业名称 比较(neq)
   */
  private String supplierFullNameNeq;
  /**
   * 企业名称 比较(gt)
   */
  private String supplierFullNameGt;
  /**
   * 企业名称 比较(gte)
   */
  private String supplierFullNameGte;
  /**
   * 企业名称 比较(lt)
   */
  private String supplierFullNameLt;
  /**
   * 企业名称 比较(lte)
   */
  private String supplierFullNameLte;
  /**
   * 企业名称 比较(contains)
   */
  private String supplierFullNameContains;
  /**
   * 企业名称 比较(notcontains)
   */
  private String supplierFullNameNotcontains;
  /**
   * 企业名称 比较(startswith)
   */
  private String supplierFullNameStartswith;
  /**
   * 企业名称 比较(endswith)
   */
  private String supplierFullNameEndswith;
  /**
   * 企业名称 比较(isnull)
   */
  private Boolean supplierFullNameIsnull;
  /**
   * 企业名称 比较(isnotnull)
   */
  private Boolean supplierFullNameIsnotnull;

  /**
   * 企业名称(精确搜索)
   */
  private List<String> supplierFullNameInList;

  /**
   * 供应商分类
   */
  private String type;

  /**
   * 供应商分类 比较(eq)
   */
  private String typeEq;
  /**
   * 供应商分类 比较(neq)
   */
  private String typeNeq;
  /**
   * 供应商分类 比较(gt)
   */
  private String typeGt;
  /**
   * 供应商分类 比较(gte)
   */
  private String typeGte;
  /**
   * 供应商分类 比较(lt)
   */
  private String typeLt;
  /**
   * 供应商分类 比较(lte)
   */
  private String typeLte;
  /**
   * 供应商分类 比较(contains)
   */
  private String typeContains;
  /**
   * 供应商分类 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 供应商分类 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 供应商分类 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 供应商分类 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 供应商分类 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 供应商分类(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 未完成原因(模糊搜索)
   */
  private String undoneReason;

  /**
   * 未完成原因 比较(eq)
   */
  private String undoneReasonEq;
  /**
   * 未完成原因 比较(neq)
   */
  private String undoneReasonNeq;
  /**
   * 未完成原因 比较(gt)
   */
  private String undoneReasonGt;
  /**
   * 未完成原因 比较(gte)
   */
  private String undoneReasonGte;
  /**
   * 未完成原因 比较(lt)
   */
  private String undoneReasonLt;
  /**
   * 未完成原因 比较(lte)
   */
  private String undoneReasonLte;
  /**
   * 未完成原因 比较(contains)
   */
  private String undoneReasonContains;
  /**
   * 未完成原因 比较(notcontains)
   */
  private String undoneReasonNotcontains;
  /**
   * 未完成原因 比较(startswith)
   */
  private String undoneReasonStartswith;
  /**
   * 未完成原因 比较(endswith)
   */
  private String undoneReasonEndswith;
  /**
   * 未完成原因 比较(isnull)
   */
  private Boolean undoneReasonIsnull;
  /**
   * 未完成原因 比较(isnotnull)
   */
  private Boolean undoneReasonIsnotnull;

  /**
   * 未完成原因(精确搜索)
   */
  private List<String> undoneReasonInList;

  /**
   * 社会信用代码(模糊搜索)
   */
  private String creditCode;

  /**
   * 社会信用代码 比较(eq)
   */
  private String creditCodeEq;
  /**
   * 社会信用代码 比较(neq)
   */
  private String creditCodeNeq;
  /**
   * 社会信用代码 比较(gt)
   */
  private String creditCodeGt;
  /**
   * 社会信用代码 比较(gte)
   */
  private String creditCodeGte;
  /**
   * 社会信用代码 比较(lt)
   */
  private String creditCodeLt;
  /**
   * 社会信用代码 比较(lte)
   */
  private String creditCodeLte;
  /**
   * 社会信用代码 比较(contains)
   */
  private String creditCodeContains;
  /**
   * 社会信用代码 比较(notcontains)
   */
  private String creditCodeNotcontains;
  /**
   * 社会信用代码 比较(startswith)
   */
  private String creditCodeStartswith;
  /**
   * 社会信用代码 比较(endswith)
   */
  private String creditCodeEndswith;
  /**
   * 社会信用代码 比较(isnull)
   */
  private Boolean creditCodeIsnull;
  /**
   * 社会信用代码 比较(isnotnull)
   */
  private Boolean creditCodeIsnotnull;

  /**
   * 社会信用代码(精确搜索)
   */
  private List<String> creditCodeInList;

  /**
   * 规模(模糊搜索)
   */
  private String scale;

  /**
   * 规模 比较(eq)
   */
  private String scaleEq;
  /**
   * 规模 比较(neq)
   */
  private String scaleNeq;
  /**
   * 规模 比较(gt)
   */
  private String scaleGt;
  /**
   * 规模 比较(gte)
   */
  private String scaleGte;
  /**
   * 规模 比较(lt)
   */
  private String scaleLt;
  /**
   * 规模 比较(lte)
   */
  private String scaleLte;
  /**
   * 规模 比较(contains)
   */
  private String scaleContains;
  /**
   * 规模 比较(notcontains)
   */
  private String scaleNotcontains;
  /**
   * 规模 比较(startswith)
   */
  private String scaleStartswith;
  /**
   * 规模 比较(endswith)
   */
  private String scaleEndswith;
  /**
   * 规模 比较(isnull)
   */
  private Boolean scaleIsnull;
  /**
   * 规模 比较(isnotnull)
   */
  private Boolean scaleIsnotnull;

  /**
   * 规模(精确搜索)
   */
  private List<String> scaleInList;

  /**
   * 联系人(模糊搜索)
   */
  private String contacts;

  /**
   * 联系人 比较(eq)
   */
  private String contactsEq;
  /**
   * 联系人 比较(neq)
   */
  private String contactsNeq;
  /**
   * 联系人 比较(gt)
   */
  private String contactsGt;
  /**
   * 联系人 比较(gte)
   */
  private String contactsGte;
  /**
   * 联系人 比较(lt)
   */
  private String contactsLt;
  /**
   * 联系人 比较(lte)
   */
  private String contactsLte;
  /**
   * 联系人 比较(contains)
   */
  private String contactsContains;
  /**
   * 联系人 比较(notcontains)
   */
  private String contactsNotcontains;
  /**
   * 联系人 比较(startswith)
   */
  private String contactsStartswith;
  /**
   * 联系人 比较(endswith)
   */
  private String contactsEndswith;
  /**
   * 联系人 比较(isnull)
   */
  private Boolean contactsIsnull;
  /**
   * 联系人 比较(isnotnull)
   */
  private Boolean contactsIsnotnull;

  /**
   * 联系人(精确搜索)
   */
  private List<String> contactsInList;

  /**
   * 联系人手机号(模糊搜索)
   */
  private String contactsPhone;

  /**
   * 联系人手机号 比较(eq)
   */
  private String contactsPhoneEq;
  /**
   * 联系人手机号 比较(neq)
   */
  private String contactsPhoneNeq;
  /**
   * 联系人手机号 比较(gt)
   */
  private String contactsPhoneGt;
  /**
   * 联系人手机号 比较(gte)
   */
  private String contactsPhoneGte;
  /**
   * 联系人手机号 比较(lt)
   */
  private String contactsPhoneLt;
  /**
   * 联系人手机号 比较(lte)
   */
  private String contactsPhoneLte;
  /**
   * 联系人手机号 比较(contains)
   */
  private String contactsPhoneContains;
  /**
   * 联系人手机号 比较(notcontains)
   */
  private String contactsPhoneNotcontains;
  /**
   * 联系人手机号 比较(startswith)
   */
  private String contactsPhoneStartswith;
  /**
   * 联系人手机号 比较(endswith)
   */
  private String contactsPhoneEndswith;
  /**
   * 联系人手机号 比较(isnull)
   */
  private Boolean contactsPhoneIsnull;
  /**
   * 联系人手机号 比较(isnotnull)
   */
  private Boolean contactsPhoneIsnotnull;

  /**
   * 联系人手机号(精确搜索)
   */
  private List<String> contactsPhoneInList;

  /**
   * QQ/微信(模糊搜索)
   */
  private String qqWx;

  /**
   * QQ/微信 比较(eq)
   */
  private String qqWxEq;
  /**
   * QQ/微信 比较(neq)
   */
  private String qqWxNeq;
  /**
   * QQ/微信 比较(gt)
   */
  private String qqWxGt;
  /**
   * QQ/微信 比较(gte)
   */
  private String qqWxGte;
  /**
   * QQ/微信 比较(lt)
   */
  private String qqWxLt;
  /**
   * QQ/微信 比较(lte)
   */
  private String qqWxLte;
  /**
   * QQ/微信 比较(contains)
   */
  private String qqWxContains;
  /**
   * QQ/微信 比较(notcontains)
   */
  private String qqWxNotcontains;
  /**
   * QQ/微信 比较(startswith)
   */
  private String qqWxStartswith;
  /**
   * QQ/微信 比较(endswith)
   */
  private String qqWxEndswith;
  /**
   * QQ/微信 比较(isnull)
   */
  private Boolean qqWxIsnull;
  /**
   * QQ/微信 比较(isnotnull)
   */
  private Boolean qqWxIsnotnull;

  /**
   * QQ/微信(精确搜索)
   */
  private List<String> qqWxInList;

  /**
   * 邮箱(模糊搜索)
   */
  private String email;

  /**
   * 邮箱 比较(eq)
   */
  private String emailEq;
  /**
   * 邮箱 比较(neq)
   */
  private String emailNeq;
  /**
   * 邮箱 比较(gt)
   */
  private String emailGt;
  /**
   * 邮箱 比较(gte)
   */
  private String emailGte;
  /**
   * 邮箱 比较(lt)
   */
  private String emailLt;
  /**
   * 邮箱 比较(lte)
   */
  private String emailLte;
  /**
   * 邮箱 比较(contains)
   */
  private String emailContains;
  /**
   * 邮箱 比较(notcontains)
   */
  private String emailNotcontains;
  /**
   * 邮箱 比较(startswith)
   */
  private String emailStartswith;
  /**
   * 邮箱 比较(endswith)
   */
  private String emailEndswith;
  /**
   * 邮箱 比较(isnull)
   */
  private Boolean emailIsnull;
  /**
   * 邮箱 比较(isnotnull)
   */
  private Boolean emailIsnotnull;

  /**
   * 邮箱(精确搜索)
   */
  private List<String> emailInList;

  /**
   * 网址(模糊搜索)
   */
  private String webAddress;

  /**
   * 网址 比较(eq)
   */
  private String webAddressEq;
  /**
   * 网址 比较(neq)
   */
  private String webAddressNeq;
  /**
   * 网址 比较(gt)
   */
  private String webAddressGt;
  /**
   * 网址 比较(gte)
   */
  private String webAddressGte;
  /**
   * 网址 比较(lt)
   */
  private String webAddressLt;
  /**
   * 网址 比较(lte)
   */
  private String webAddressLte;
  /**
   * 网址 比较(contains)
   */
  private String webAddressContains;
  /**
   * 网址 比较(notcontains)
   */
  private String webAddressNotcontains;
  /**
   * 网址 比较(startswith)
   */
  private String webAddressStartswith;
  /**
   * 网址 比较(endswith)
   */
  private String webAddressEndswith;
  /**
   * 网址 比较(isnull)
   */
  private Boolean webAddressIsnull;
  /**
   * 网址 比较(isnotnull)
   */
  private Boolean webAddressIsnotnull;

  /**
   * 网址(精确搜索)
   */
  private List<String> webAddressInList;

  /**
   * 省(模糊搜索)
   */
  private String province;

  /**
   * 省 比较(eq)
   */
  private String provinceEq;
  /**
   * 省 比较(neq)
   */
  private String provinceNeq;
  /**
   * 省 比较(gt)
   */
  private String provinceGt;
  /**
   * 省 比较(gte)
   */
  private String provinceGte;
  /**
   * 省 比较(lt)
   */
  private String provinceLt;
  /**
   * 省 比较(lte)
   */
  private String provinceLte;
  /**
   * 省 比较(contains)
   */
  private String provinceContains;
  /**
   * 省 比较(notcontains)
   */
  private String provinceNotcontains;
  /**
   * 省 比较(startswith)
   */
  private String provinceStartswith;
  /**
   * 省 比较(endswith)
   */
  private String provinceEndswith;
  /**
   * 省 比较(isnull)
   */
  private Boolean provinceIsnull;
  /**
   * 省 比较(isnotnull)
   */
  private Boolean provinceIsnotnull;

  /**
   * 省(精确搜索)
   */
  private List<String> provinceInList;

  /**
   * 市(模糊搜索)
   */
  private String city;

  /**
   * 市 比较(eq)
   */
  private String cityEq;
  /**
   * 市 比较(neq)
   */
  private String cityNeq;
  /**
   * 市 比较(gt)
   */
  private String cityGt;
  /**
   * 市 比较(gte)
   */
  private String cityGte;
  /**
   * 市 比较(lt)
   */
  private String cityLt;
  /**
   * 市 比较(lte)
   */
  private String cityLte;
  /**
   * 市 比较(contains)
   */
  private String cityContains;
  /**
   * 市 比较(notcontains)
   */
  private String cityNotcontains;
  /**
   * 市 比较(startswith)
   */
  private String cityStartswith;
  /**
   * 市 比较(endswith)
   */
  private String cityEndswith;
  /**
   * 市 比较(isnull)
   */
  private Boolean cityIsnull;
  /**
   * 市 比较(isnotnull)
   */
  private Boolean cityIsnotnull;

  /**
   * 市(精确搜索)
   */
  private List<String> cityInList;

  /**
   * 地区(模糊搜索)
   */
  private String region;

  /**
   * 地区 比较(eq)
   */
  private String regionEq;
  /**
   * 地区 比较(neq)
   */
  private String regionNeq;
  /**
   * 地区 比较(gt)
   */
  private String regionGt;
  /**
   * 地区 比较(gte)
   */
  private String regionGte;
  /**
   * 地区 比较(lt)
   */
  private String regionLt;
  /**
   * 地区 比较(lte)
   */
  private String regionLte;
  /**
   * 地区 比较(contains)
   */
  private String regionContains;
  /**
   * 地区 比较(notcontains)
   */
  private String regionNotcontains;
  /**
   * 地区 比较(startswith)
   */
  private String regionStartswith;
  /**
   * 地区 比较(endswith)
   */
  private String regionEndswith;
  /**
   * 地区 比较(isnull)
   */
  private Boolean regionIsnull;
  /**
   * 地区 比较(isnotnull)
   */
  private Boolean regionIsnotnull;

  /**
   * 地区(精确搜索)
   */
  private List<String> regionInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 状态
   */
  private String status;

  /**
   * 状态 比较(eq)
   */
  private String statusEq;
  /**
   * 状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 状态 比较(gt)
   */
  private String statusGt;
  /**
   * 状态 比较(gte)
   */
  private String statusGte;
  /**
   * 状态 比较(lt)
   */
  private String statusLt;
  /**
   * 状态 比较(lte)
   */
  private String statusLte;
  /**
   * 状态 比较(contains)
   */
  private String statusContains;
  /**
   * 状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 是否有 附件
   */
  private Boolean file;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 是否有 工牌胸卡
   */
  private Boolean workBadge;

  /**
   * 流程编码
   */
  private String enCode;

  /**
   * 流程编码 比较(eq)
   */
  private String enCodeEq;
  /**
   * 流程编码 比较(neq)
   */
  private String enCodeNeq;
  /**
   * 流程编码 比较(gt)
   */
  private String enCodeGt;
  /**
   * 流程编码 比较(gte)
   */
  private String enCodeGte;
  /**
   * 流程编码 比较(lt)
   */
  private String enCodeLt;
  /**
   * 流程编码 比较(lte)
   */
  private String enCodeLte;
  /**
   * 流程编码 比较(contains)
   */
  private String enCodeContains;
  /**
   * 流程编码 比较(notcontains)
   */
  private String enCodeNotcontains;
  /**
   * 流程编码 比较(startswith)
   */
  private String enCodeStartswith;
  /**
   * 流程编码 比较(endswith)
   */
  private String enCodeEndswith;
  /**
   * 流程编码 比较(isnull)
   */
  private Boolean enCodeIsnull;
  /**
   * 流程编码 比较(isnotnull)
   */
  private Boolean enCodeIsnotnull;

  /**
   * 流程编码(精确搜索)
   */
  private List<String> enCodeInList;

  /**
   * 转交人
   */
  private Long forwardUser;

  /**
   * 转交人 比较(eq)
   */
  private Long forwardUserEq;
  /**
   * 转交人 比较(neq)
   */
  private Long forwardUserNeq;
  /**
   * 转交人 比较(gt)
   */
  private Long forwardUserGt;
  /**
   * 转交人 比较(gte)
   */
  private Long forwardUserGte;
  /**
   * 转交人 比较(lt)
   */
  private Long forwardUserLt;
  /**
   * 转交人 比较(lte)
   */
  private Long forwardUserLte;
  /**
   * 转交人 比较(contains)
   */
  private Long forwardUserContains;
  /**
   * 转交人 比较(notcontains)
   */
  private Long forwardUserNotcontains;
  /**
   * 转交人 比较(startswith)
   */
  private Long forwardUserStartswith;
  /**
   * 转交人 比较(endswith)
   */
  private Long forwardUserEndswith;
  /**
   * 转交人 比较(isnull)
   */
  private Boolean forwardUserIsnull;
  /**
   * 转交人 比较(isnotnull)
   */
  private Boolean forwardUserIsnotnull;
  /**
   * 转交人的显示用户名 比较(eq)
   */
  private String forwardUserNameEq;
  /**
   * 转交人的显示用户名 比较(neq)
   */
  private String forwardUserNameNeq;
  /**
   * 转交人的显示用户名 比较(gt)
   */
  private String forwardUserNameGt;
  /**
   * 转交人的显示用户名 比较(gte)
   */
  private String forwardUserNameGte;
  /**
   * 转交人的显示用户名 比较(lt)
   */
  private String forwardUserNameLt;
  /**
   * 转交人的显示用户名 比较(lte)
   */
  private String forwardUserNameLte;
  /**
   * 转交人的显示用户名 比较(contains)
   */
  private String forwardUserNameContains;
  /**
   * 转交人的显示用户名 比较(notcontains)
   */
  private String forwardUserNameNotcontains;
  /**
   * 转交人的显示用户名 比较(startswith)
   */
  private String forwardUserNameStartswith;
  /**
   * 转交人的显示用户名 比较(endswith)
   */
  private String forwardUserNameEndswith;
  /**
   * 转交人的显示用户名 比较(isnull)
   */
  private Boolean forwardUserNameIsnull;
  /**
   * 转交人的显示用户名 比较(isnotnull)
   */
  private Boolean forwardUserNameIsnotnull;

  /**
   * 转交人(范围搜索)
   */
  private List<Long> forwardUserInList;

  /**
   * 综合评分
   */
  private java.math.BigDecimal systemReviewScoring;

  /**
   * 最小综合评分
   */
  private java.math.BigDecimal systemReviewScoringMin;

  /**
   * 最大综合评分
   */
  private java.math.BigDecimal systemReviewScoringMax;

  /**
   * 综合评分 比较(eq)
   */
  private java.math.BigDecimal systemReviewScoringEq;
  /**
   * 综合评分 比较(neq)
   */
  private java.math.BigDecimal systemReviewScoringNeq;
  /**
   * 综合评分 比较(gt)
   */
  private java.math.BigDecimal systemReviewScoringGt;
  /**
   * 综合评分 比较(gte)
   */
  private java.math.BigDecimal systemReviewScoringGte;
  /**
   * 综合评分 比较(lt)
   */
  private java.math.BigDecimal systemReviewScoringLt;
  /**
   * 综合评分 比较(lte)
   */
  private java.math.BigDecimal systemReviewScoringLte;
  /**
   * 综合评分 比较(contains)
   */
  private java.math.BigDecimal systemReviewScoringContains;
  /**
   * 综合评分 比较(notcontains)
   */
  private java.math.BigDecimal systemReviewScoringNotcontains;
  /**
   * 综合评分 比较(startswith)
   */
  private java.math.BigDecimal systemReviewScoringStartswith;
  /**
   * 综合评分 比较(endswith)
   */
  private java.math.BigDecimal systemReviewScoringEndswith;
  /**
   * 综合评分 比较(isnull)
   */
  private Boolean systemReviewScoringIsnull;
  /**
   * 综合评分 比较(isnotnull)
   */
  private Boolean systemReviewScoringIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
